const { get, post } = require("../../utils/request");

Page({
  /**
   * 页面的初始数据
   */
  data: {
    orderId: null, // 订单ID
    location: "", // 场地位置/名称
    date: "", // 预约日期
    time: "", // 预约时间段
    reserveTime: "", // 完整预约时间
    money: "0", // 单价
    total: "0", // 总金额
    isLoading: true, // 是否正在加载数据
    courts: {}, // 场地信息

    // 红包相关
    redPackets: [], // 可用红包列表
    selectedRedPacket: null, // 选中的红包
    redPacketAmount: 0, // 红包金额
    finalAmount: "0", // 最终支付金额
    showRedPackets: false, // 是否显示红包列表

    // 余额支付相关
    rechargeBalance: "0", // 充值余额
    giftBalance: "0", // 赠送金额
    totalBalance: "0", // 总余额
    useBalancePayment: false, // 是否使用余额支付
    balancePaymentAvailable: false, // 余额是否足够支付
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log("支付页面接收到的参数:", options);

    if (!options.orderId) {
      wx.showToast({
        title: "订单信息不完整",
        icon: "none",
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      return;
    }

    // 保存订单ID
    this.setData({
      orderId: options.orderId,
      isLoading: true,
    });

    // 加载场地信息
    this.loadCourts();

    // 根据订单ID获取订单详情
    this.getOrderDetail(options.orderId);

    // 获取可用红包
    this.getAvailableRedPackets();

    // 获取用户余额
    this.getUserBalance();
  },

  /**
   * 获取场地信息
   */
  loadCourts: function () {
    get("/court/list")
      .then((res) => {
        if (res.code === 200) {
          const courts = {};
          const courtList = res.data || [];
          // 将场地ID作为键，场地名称作为值存入对象中
          courtList.forEach((court) => {
            courts[court.id] = court.name;
          });
          this.setData({ courts });
        }
      })
      .catch((err) => {
        console.error("获取场地信息失败:", err);
      });
  },

  /**
   * 根据订单ID获取订单详情
   */
  getOrderDetail: function (orderId) {
    get(`/order/${orderId}`)
      .then((res) => {
        if (res.code === 200) {
          const order = res.data;

          if (!order) {
            wx.showToast({
              title: "未找到订单信息",
              icon: "none",
            });
            setTimeout(() => {
              wx.navigateBack();
            }, 1500);
            return;
          }

          // 处理场地名称
          const courtName =
            this.data.courts[order.courtId] || `场地${order.courtId}`;

          // 格式化日期和时间
          const startDate = this.formatDate(order.startTime);
          const startTime = this.formatTime(order.startTime);
          const endTime = this.formatTime(order.endTime);

          // 设置订单信息
          this.setData({
            location: courtName,
            date: startDate,
            time: `${startTime}-${endTime}`,
            reserveTime: `${startDate} ${startTime}-${endTime}`,
            money: order.totalAmount,
            total: order.totalAmount,
            finalAmount: order.totalAmount,
            isLoading: false,
          });
        } else {
          wx.showToast({
            title: res.message || "获取订单详情失败",
            icon: "none",
          });
          this.setData({ isLoading: false });
        }
      })
      .catch((err) => {
        console.error("获取订单详情失败:", err);
        wx.showToast({
          title: "获取订单详情失败",
          icon: "none",
        });
        this.setData({ isLoading: false });
      });
  },

  /**
   * 获取可用红包
   */
  getAvailableRedPackets: function () {
    const app = getApp();
    const loginStatus = app.checkLoginStatus();

    if (!loginStatus.isLoggedIn) {
      return;
    }

    const userId = loginStatus.userInfo.id;

    get(`/coupon/user/${userId}`, { status: "未使用" })
      .then((res) => {
        if (res.code === 200) {
          const redPackets = res.data || [];
          this.setData({ redPackets });
        } else {
          console.error("获取红包列表失败:", res.message);
        }
      })
      .catch((err) => {
        console.error("获取红包列表失败:", err);
      });
  },

  /**
   * 获取用户余额
   */
  getUserBalance: function () {
    const app = getApp();
    const loginStatus = app.checkLoginStatus();

    if (!loginStatus.isLoggedIn) {
      return;
    }

    const userInfo = loginStatus.userInfo;

    // 从用户信息中获取余额数据
    if (userInfo) {
      const rechargeBalance = parseFloat(userInfo.rechargeBalance || 0).toFixed(
        2
      );
      const giftBalance = parseFloat(userInfo.giftBalance || 0).toFixed(2);
      const totalBalance = parseFloat(
        Number(rechargeBalance) + Number(giftBalance)
      ).toFixed(2);

      this.setData({
        rechargeBalance,
        giftBalance,
        totalBalance,
      });

      // 检查余额是否足够支付
      this.checkBalancePaymentAvailability();
      return;
    }

    // 如果用户信息中没有余额数据，则请求最新的用户信息
    const userId = userInfo.id;

    get(`/user/info`)
      .then((res) => {
        if (res.code === 200 && res.data) {
          // 更新本地存储的用户信息
          const updatedUserInfo = res.data;
          wx.setStorageSync("userInfo", updatedUserInfo);

          // 获取余额信息
          const rechargeBalance = parseFloat(
            updatedUserInfo.rechargeBalance || 0
          ).toFixed(2);
          const giftBalance = parseFloat(
            updatedUserInfo.giftBalance || 0
          ).toFixed(2);
          const totalBalance = parseFloat(
            Number(rechargeBalance) + Number(giftBalance)
          ).toFixed(2);

          this.setData({
            rechargeBalance,
            giftBalance,
            totalBalance,
          });

          // 检查余额是否足够支付
          this.checkBalancePaymentAvailability();
        } else {
          console.error("获取用户信息失败:", res.message);
        }
      })
      .catch((err) => {
        console.error("获取用户信息失败:", err);
      });
  },

  /**
   * 检查余额是否足够支付
   */
  checkBalancePaymentAvailability: function () {
    const totalBalance = parseFloat(this.data.totalBalance);
    const finalAmount = parseFloat(this.data.finalAmount);

    // 余额大于等于支付金额时可用
    const balancePaymentAvailable = totalBalance >= finalAmount;

    this.setData({ balancePaymentAvailable });
  },

  /**
   * 切换支付方式
   */
  togglePaymentMethod: function (e) {
    const method = e.currentTarget.dataset.method;

    // 如果选择余额支付但余额不足，则不允许切换
    if (method === "balance" && !this.data.balancePaymentAvailable) {
      wx.showToast({
        title: "余额不足，请先充值",
        icon: "none",
      });
      return;
    }

    const useBalancePayment = method === "balance";
    this.setData({ useBalancePayment });
  },

  /**
   * 显示红包列表
   */
  showRedPacketList: function () {
    this.setData({
      showRedPackets: true,
    });
  },

  /**
   * 隐藏红包列表
   */
  hideRedPacketList: function () {
    this.setData({
      showRedPackets: false,
    });
  },

  /**
   * 选择红包
   */
  selectRedPacket: function (e) {
    const redPacketId = e.currentTarget.dataset.id;
    const selectedRedPacket = this.data.redPackets.find(
      (item) => item.id == redPacketId
    );

    if (selectedRedPacket) {
      const redPacketAmount = parseFloat(selectedRedPacket.amount);
      const totalAmount = parseFloat(this.data.total);
      // 计算使用红包后的最终金额，不少于0元
      const finalAmount = Math.max(0, totalAmount - redPacketAmount).toFixed(2);

      this.setData({
        selectedRedPacket,
        redPacketAmount,
        finalAmount,
        showRedPackets: false,
      });

      // 更新余额支付可用性
      this.checkBalancePaymentAvailability();
    }
  },

  /**
   * 不使用红包
   */
  clearRedPacket: function () {
    this.setData({
      selectedRedPacket: null,
      redPacketAmount: 0,
      finalAmount: this.data.total,
      showRedPackets: false,
    });

    // 更新余额支付可用性
    this.checkBalancePaymentAvailability();
  },

  /**
   * 计算使用的余额明细
   * 优先使用赠送余额，然后再使用充值余额
   */
  calculateBalanceUsage: function (amount) {
    const userInfo = wx.getStorageSync("userInfo");
    const giftBalance = parseFloat(userInfo.giftBalance || 0);
    const rechargeBalance = parseFloat(userInfo.rechargeBalance || 0);

    console.log("计算余额使用 - 初始值:", {
      amount,
      giftBalance,
      rechargeBalance,
      totalAvailable: (giftBalance + rechargeBalance).toFixed(2),
    });

    // 优先使用赠送余额
    const giftUsed = Math.min(giftBalance, amount);

    // 如果赠送余额不足，再使用充值余额
    const remainingAmount = amount - giftUsed;
    const rechargeUsed = Math.min(rechargeBalance, remainingAmount);

    // 计算使用后的余额
    const newGiftBalance = (giftBalance - giftUsed).toFixed(2);
    const newRechargeBalance = (rechargeBalance - rechargeUsed).toFixed(2);

    const result = {
      giftUsed: giftUsed.toFixed(2),
      rechargeUsed: rechargeUsed.toFixed(2),
      totalUsed: (giftUsed + rechargeUsed).toFixed(2),
      newGiftBalance,
      newRechargeBalance,
    };

    console.log("计算余额使用 - 结果:", result);

    return result;
  },

  /**
   * 确认支付
   */
  confirmPayment: function () {
    if (!this.data.orderId) {
      wx.showToast({
        title: "订单信息不完整",
        icon: "none",
      });
      return;
    }

    // 检查用户是否登录
    const app = getApp();
    const loginStatus = app.checkLoginStatus();
    if (!loginStatus.isLoggedIn) {
      wx.showToast({
        title: "请先登录",
        icon: "none",
      });
      setTimeout(() => {
        wx.navigateTo({
          url: "/pages/registration/registration",
        });
      }, 1500);
      return;
    }

    // 检查余额是否足够支付
    const totalBalance = parseFloat(this.data.totalBalance);
    const finalAmount = parseFloat(this.data.finalAmount);

    console.log("当前支付前状态:", {
      totalBalance,
      finalAmount,
      rechargeBalance: this.data.rechargeBalance,
      giftBalance: this.data.giftBalance,
    });

    // 如果余额足够，优先使用余额支付（无论用户选择了哪种支付方式）
    if (totalBalance >= finalAmount) {
      // 计算使用的余额明细
      const balanceUsage = this.calculateBalanceUsage(finalAmount);

      // 打印计算出的余额使用情况
      console.log("计算出的余额使用情况:", balanceUsage);

      // 弹出确认对话框，显示使用的余额明细
      wx.showModal({
        title: "确认支付",
        content: `检测到您的余额充足，是否使用余额支付？\n赠送余额：￥${balanceUsage.giftUsed}\n充值余额：￥${balanceUsage.rechargeUsed}\n总计：￥${balanceUsage.totalUsed}`,
        confirmText: "使用余额",
        cancelText: "微信支付",
        success: (res) => {
          if (res.confirm) {
            // 用户确认使用余额支付
            this.balancePayment(balanceUsage);
          } else {
            // 用户选择微信支付
            this.wxPayment();
          }
        },
      });
      return;
    }

    // 如果用户明确选择了余额支付，但余额不足
    if (this.data.useBalancePayment) {
      wx.showModal({
        title: "余额不足",
        content: `您的余额￥${this.data.totalBalance}不足以支付￥${this.data.finalAmount}，是否去充值？`,
        confirmText: "去充值",
        cancelText: "微信支付",
        success: (res) => {
          if (res.confirm) {
            // 跳转到充值页面
            this.navigateToRecharge();
          } else {
            // 切换到微信支付
            this.setData({ useBalancePayment: false });
            this.wxPayment();
          }
        },
      });
      return;
    }

    // 用户选择微信支付
    this.wxPayment();
  },

  /**
   * 微信支付流程
   */
  wxPayment: function () {
    // 显示加载提示
    wx.showLoading({
      title: "准备支付中...",
      mask: true,
    });

    // 以下是原有的微信支付流程
    // 每次支付前都重新获取openid，确保支付使用的是最新的openid
    console.log("支付前重新获取openid...");

    // 调用微信登录获取临时凭证code
    wx.login({
      success: (loginRes) => {
        if (loginRes.code) {
          console.log("获取到微信登录code:", loginRes.code);

          // 使用code请求后端获取openid
          const { post } = require("../../utils/request");

          // 清晰地显示请求参数
          const requestData = { code: loginRes.code };
          console.log("请求openid的参数:", requestData);

          post("/user/wx-code-to-openid", requestData, {
            showLoading: false, // 不显示额外的loading，以免与当前的冲突
          })
            .then((res) => {
              console.log("获取openid请求成功，完整响应:", res);

              if (res.code === 200 && res.data && res.data.openid) {
                const openid = res.data.openid;
                console.log("成功获取openid:", openid);

                // 保存最新的openid到本地
                wx.setStorageSync("openid", openid);

                // 更新用户信息中的openid
                const userInfo = wx.getStorageSync("userInfo");
                if (userInfo) {
                  userInfo.openid = openid;
                  wx.setStorageSync("userInfo", userInfo);
                }

                // 继续支付流程
                this.processPayment(openid);
              } else {
                wx.hideLoading();
                console.error("获取openid失败，响应数据不符合预期:", res);
                wx.showModal({
                  title: "支付初始化失败",
                  content: "获取支付信息失败，请稍后重试",
                  showCancel: false,
                });
              }
            })
            .catch((err) => {
              wx.hideLoading();
              console.error("请求openid失败，详细错误:", err);

              // 显示更详细的错误信息
              let errorMsg = "支付初始化失败";
              if (err && err.message) {
                errorMsg += "，原因：" + err.message;
              }

              wx.showModal({
                title: "获取支付信息失败",
                content: errorMsg,
                showCancel: false,
              });
            });
        } else {
          wx.hideLoading();
          console.error("wx.login失败，无法获取code:", loginRes);
          wx.showToast({
            title: "支付初始化失败",
            icon: "none",
          });
        }
      },
      fail: (err) => {
        wx.hideLoading();
        console.error("wx.login调用失败，详细错误:", err);
        wx.showToast({
          title: "支付初始化失败，请重试",
          icon: "none",
        });
      },
    });
  },

  /**
   * 处理支付流程
   */
  processPayment: function (openid) {
    // 计算实际支付金额（单位：分）
    const amount = Math.floor(parseFloat(this.data.finalAmount) * 100);
    // 实际显示金额
    const displayAmount = this.data.finalAmount;

    // 订单描述
    const description = `网球场地预约: ${this.data.reserveTime}`;

    console.log(`发起支付: 金额￥${displayAmount}，openid:${openid}`);

    // 将请求参数作为query参数传递 - 适配后端PaymentController的接口要求
    // 创建查询字符串
    const queryParams = `?openid=${encodeURIComponent(
      openid
    )}&amount=${amount}&description=${encodeURIComponent(description)}`;

    // 发送请求，传递空对象作为请求体，查询参数在URL中
    post(`/pay/jsapi${queryParams}`, {})
      .then((res) => {
        wx.hideLoading();
        if (res.code === 200) {
          const prepayParams = res.data;
          console.log("获取到的支付参数:", prepayParams);

          // 调用微信支付
          wx.requestPayment({
            timeStamp: prepayParams.timeStamp,
            nonceStr: prepayParams.nonceStr,
            package: prepayParams.package,
            signType: prepayParams.signType,
            paySign: prepayParams.paySign,
            success: (result) => {
              console.log("支付成功:", result);

              // 支付成功后，更新订单状态
              const params = {
                id: Number(this.data.orderId),
                payStatus: "paid",
              };

              // 如果选择了红包，传递红包ID
              if (this.data.selectedRedPacket) {
                params.couponId = Number(this.data.selectedRedPacket.id);
              } else {
                params.couponId = null;
              }

              // 调用订单状态更新接口
              post("/order/pay", params)
                .then((updateRes) => {
                  if (updateRes.code === 200) {
                    // 准备支付成功提示信息
                    let successMsg = "支付成功";

                    // 如果使用了红包，添加到提示中
                    if (this.data.selectedRedPacket) {
                      successMsg = `支付成功，使用红包￥${this.data.redPacketAmount}`;
                    }

                    wx.showModal({
                      title: "支付结果",
                      content: `${successMsg}，实付金额￥${displayAmount}`,
                      showCancel: false,
                      success: () => {
                        // 返回订单页面
                        wx.navigateBack();
                      },
                    });
                  } else {
                    wx.showToast({
                      title: updateRes.message || "订单状态更新失败",
                      icon: "none",
                    });
                  }
                })
                .catch((err) => {
                  console.error("订单状态更新失败:", err);
                  wx.showToast({
                    title: "订单状态更新失败，请联系客服",
                    icon: "none",
                  });
                });
            },
            fail: (err) => {
              console.error("支付失败:", err);
              if (err.errMsg === "requestPayment:fail cancel") {
                wx.showToast({
                  title: "支付已取消",
                  icon: "none",
                });
              } else {
                wx.showToast({
                  title: "支付失败，请重试",
                  icon: "none",
                });
              }
            },
          });
        } else {
          wx.showToast({
            title: res.message || "创建支付订单失败",
            icon: "none",
          });
        }
      })
      .catch((err) => {
        wx.hideLoading();
        console.error("创建支付订单失败:", err);
        wx.showToast({
          title: "创建支付订单失败，请稍后重试",
          icon: "none",
        });
      });
  },

  /**
   * 余额支付
   * @param {Object} balanceUsage 余额使用明细
   */
  balancePayment: function (balanceUsage) {
    // 如果没有传入余额使用明细，重新计算
    if (!balanceUsage) {
      balanceUsage = this.calculateBalanceUsage(
        parseFloat(this.data.finalAmount)
      );
    }

    // 显示加载提示
    wx.showLoading({
      title: "处理中...",
      mask: true,
    });

    const app = getApp();
    const loginStatus = app.checkLoginStatus();
    const userId = loginStatus.userInfo.id;

    // 计算实际支付金额
    const amount = parseFloat(this.data.finalAmount);

    // 构建支付参数 - 简化后只包含必要字段
    const params = {
      userId: userId,
      orderId: Number(this.data.orderId),
      giftBalance: balanceUsage.newGiftBalance, // 剩余赠送余额
      rechargeBalance: balanceUsage.newRechargeBalance, // 剩余充值余额
      payStatus: "paid", // 直接标记为已支付
      status: "normal", // 直接标记为未使用
    };

    // 如果选择了红包，传递红包ID
    if (this.data.selectedRedPacket) {
      params.couponId = Number(this.data.selectedRedPacket.id);
    }

    // 打印传递给后端的完整参数
    console.log("传递给后端的余额支付参数:", JSON.stringify(params, null, 2));

    // 调用新的余额支付接口
    post("/order/balance-pay", params)
      .then((res) => {
        wx.hideLoading();
        if (res.code === 200) {
          // 支付成功，更新本地用户余额信息
          const userInfo = wx.getStorageSync("userInfo");
          if (userInfo) {
            // 更新用户信息中的余额
            userInfo.rechargeBalance = balanceUsage.newRechargeBalance;
            userInfo.giftBalance = balanceUsage.newGiftBalance;

            // 保存更新后的用户信息
            wx.setStorageSync("userInfo", userInfo);

            // 更新页面显示
            this.setData({
              rechargeBalance: balanceUsage.newRechargeBalance,
              giftBalance: balanceUsage.newGiftBalance,
              totalBalance: (
                parseFloat(balanceUsage.newRechargeBalance) +
                parseFloat(balanceUsage.newGiftBalance)
              ).toFixed(2),
            });
          }

          // 支付成功
          let successMsg = "余额支付成功";

          // 如果使用了红包，添加到提示中
          if (this.data.selectedRedPacket) {
            successMsg = `余额支付成功，使用红包￥${this.data.redPacketAmount}`;
          }

          // 打印支付成功后的用户余额
          console.log("支付成功后的余额状态:", {
            rechargeBalance: balanceUsage.newRechargeBalance,
            giftBalance: balanceUsage.newGiftBalance,
            totalBalance: (
              parseFloat(balanceUsage.newRechargeBalance) +
              parseFloat(balanceUsage.newGiftBalance)
            ).toFixed(2),
          });

          wx.showModal({
            title: "支付结果",
            content: `${successMsg}
使用赠送余额：￥${balanceUsage.giftUsed}
使用充值余额：￥${balanceUsage.rechargeUsed}
实付金额：￥${this.data.finalAmount}`,
            showCancel: false,
            success: () => {
              // 返回订单页面
              wx.navigateBack();
            },
          });
        } else {
          console.error("余额支付失败，后端返回:", res);
          wx.showToast({
            title: res.message || "余额支付失败",
            icon: "none",
          });
        }
      })
      .catch((err) => {
        wx.hideLoading();
        console.error("余额支付失败:", err);
        wx.showToast({
          title: "余额支付失败，请稍后重试",
          icon: "none",
        });
      });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {},

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {},

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {},

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {},

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {},

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {},

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {},

  /**
   * 跳转到充值页面
   */
  navigateToRecharge: function () {
    wx.navigateTo({
      url: "/pages/recharge/recharge",
    });
  },

  /**
   * 标记订单为已使用
   */
  markOrderAsUsed: function () {
    if (!this.data.orderId) {
      wx.showToast({
        title: "订单信息不完整",
        icon: "none",
      });
      return;
    }

    wx.showModal({
      title: "确认使用",
      content: "确认使用此预约？标记后将无法再次使用。",
      success: (res) => {
        if (res.confirm) {
          // 显示加载提示
          wx.showLoading({
            title: "处理中...",
            mask: true,
          });

          // 调用标记为已使用接口
          get("/order/mark-used", { id: Number(this.data.orderId) })
            .then((res) => {
              wx.hideLoading();
              if (res.code === 200) {
                wx.showToast({
                  title: "标记使用成功",
                  icon: "success",
                });
                // 返回订单页面
                setTimeout(() => {
                  wx.navigateBack();
                }, 1500);
              } else {
                wx.showToast({
                  title: res.message || "操作失败",
                  icon: "none",
                });
              }
            })
            .catch((err) => {
              wx.hideLoading();
              console.error("使用订单失败:", err);
              wx.showToast({
                title: "操作失败，请稍后重试",
                icon: "none",
              });
            });
        }
      },
    });
  },

  /**
   * 格式化日期 YYYY-MM-DD
   */
  formatDate: function (dateTimeStr) {
    if (!dateTimeStr) return "";
    const date = new Date(dateTimeStr);
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, "0");
    const day = date.getDate().toString().padStart(2, "0");
    return `${year}-${month}-${day}`;
  },

  /**
   * 格式化时间 HH:MM
   */
  formatTime: function (dateTimeStr) {
    if (!dateTimeStr) return "";
    const date = new Date(dateTimeStr);
    const hours = date.getHours().toString().padStart(2, "0");
    const minutes = date.getMinutes().toString().padStart(2, "0");
    return `${hours}:${minutes}`;
  },
});
